-------------------------------------------------------------------------------
--rom_exp_sig_gen
--Created (25.08.2011)
--Created by Alina Ivanova
--Modified (date, by whom)
--Version 1.0
--rom for test exponentional signal generator
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
-- VHDL test_sig_gen
-------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use     work.package_settings.all;

entity rom_exp_sig_gen is
	port(
		address                                     : in  std_logic_vector (8 downto 0);
		clock                                       : in  std_logic;
		q                                           : out std_logic_vector (SIZE_ADC_DATA downto 0));
end rom_exp_sig_gen;
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
architecture functional of rom_exp_sig_gen is
begin
	Process_1: process(clock, address)
	begin
		if (rising_edge(clock)) then
			case address is
				when "000000000" => q                  <= "000000000000";
				when "000000001" => q                  <= "100001110110";
				when "000000010" => q                  <= "101101110110";
				when "000000011" => q                  <= "110001110100";
				when "000000100" => q                  <= "110010110110";

				when "000000101" => q                  <= "110010110010";
				when "000000110" => q                  <= "110010010110";
				when "000000111" => q                  <= "110001110000";
				when "000001000" => q                  <= "110001001000";
				when "000001001" => q                  <= "110000011111";

				when "000001010" => q                  <= "101111110110";
				when "000001011" => q                  <= "101111001110";
				when "000001100" => q                  <= "101110100110";
				when "000001101" => q                  <= "101101111110";
				when "000001110" => q                  <= "101101011000";

				when "000001111" => q                  <= "101100110001";
				when "000010000" => q                  <= "101100001011";
				when "000010001" => q                  <= "101011100110";
				when "000010010" => q                  <= "101011000001";
				when "000010011" => q                  <= "101010011100";

				when "000010100" => q                  <= "101001111000";
				when "000010101" => q                  <= "101001010101";
				when "000010110" => q                  <= "101000110010";
				when "000010111" => q                  <= "101000001111";
				when "000011000" => q                  <= "100111101101";

				when "000011001" => q                  <= "100111001011";
				when "000011010" => q                  <= "100110101010";
				when "000011011" => q                  <= "100110001001";
				when "000011100" => q                  <= "100101101001";
				when "000011101" => q                  <= "100101001001";

				when "000011110" => q                  <= "100100101010";
				when "000011111" => q                  <= "100100001011";
				when "000100000" => q                  <= "100011101100";
				when "000100001" => q                  <= "100011001110";
				when "000100010" => q                  <= "100010110000";

				when "000100011" => q                  <= "100010010010";
				when "000100100" => q                  <= "100001110101";
				when "000100101" => q                  <= "100001011001";
				when "000100110" => q                  <= "100000111100";
				when "000100111" => q                  <= "100000100000";

				when "000101000" => q                  <= "100000000101";
				when "000101001" => q                  <= "011111101010";
				when "000101010" => q                  <= "011111001111";
				when "000101011" => q                  <= "011110110100";
				when "000101100" => q                  <= "011110011010";

				when "000101101" => q                  <= "011110000000";
				when "000101110" => q                  <= "011101100111";
				when "000101111" => q                  <= "011101001110";
				when "000110000" => q                  <= "011100110101";
				when "000110001" => q                  <= "011100011101";

				when "000110010" => q                  <= "011100000100";
				when "000110011" => q                  <= "011011101101";
				when "000110100" => q                  <= "011011010101";
				when "000110101" => q                  <= "011010111110";
				when "000110110" => q                  <= "011010100111";

				when "000110111" => q                  <= "011010010001";
				when "000111000" => q                  <= "011001111010";
				when "000111001" => q                  <= "011001100100";
				when "000111010" => q                  <= "011001001111";
				when "000111011" => q                  <= "011000111001";

				when "000111100" => q                  <= "011000100100";
				when "000111101" => q                  <= "011000001111";
				when "000111110" => q                  <= "010111111011";
				when "000111111" => q                  <= "010111100110";
				when "001000000" => q                  <= "010111010010";

				when "001000001" => q                  <= "010110111111";
				when "001000010" => q                  <= "010110101011";
				when "001000011" => q                  <= "010110011000";
				when "001000100" => q                  <= "010110000101";
				when "001000101" => q                  <= "010101110010";

				when "001000110" => q                  <= "010101100000";
				when "001000111" => q                  <= "010101001110";
				when "001001000" => q                  <= "010100111100";
				when "001001001" => q                  <= "010100101010";
				when "001001010" => q                  <= "010100011000";

				when "001001011" => q                  <= "010100000111";
				when "001001100" => q                  <= "010011110110";
				when "001001101" => q                  <= "010011100101";
				when "001001110" => q                  <= "010011010101";
				when "001001111" => q                  <= "010011000100";

				when "001010000" => q                  <= "010010110100";
				when "001010001" => q                  <= "010010100100";
				when "001010010" => q                  <= "010010010100";
				when "001010011" => q                  <= "010010000101";
				when "001010100" => q                  <= "010001110101";

				when "001010101" => q                  <= "010001100110";
				when "001010110" => q                  <= "010001010111";
				when "001010111" => q                  <= "010001001001";
				when "001011000" => q                  <= "010000111010";
				when "001011001" => q                  <= "010000101100";

				when "001011010" => q                  <= "010000011110";
				when "001011011" => q                  <= "010000010000";
				when "001011100" => q                  <= "010000000010";
				when "001011101" => q                  <= "001111110100";
				when "001011110" => q                  <= "001111100111";

				when "001011111" => q                  <= "001111011010";
				when "001100000" => q                  <= "001111001101";
				when "001100001" => q                  <= "001111000000";
				when "001100010" => q                  <= "001110110011";
				when "001100011" => q                  <= "001110100110";

				when "001100100" => q                  <= "001110011010";
				when "001100101" => q                  <= "001110001110";
				when "001100110" => q                  <= "001110000010";
				when "001100111" => q                  <= "001101110110";
				when "001101000" => q                  <= "001101101010";

				when "001101001" => q                  <= "001101011111";
				when "001101010" => q                  <= "001101010011";
				when "001101011" => q                  <= "001101001000";
				when "001101100" => q                  <= "001100111101";
				when "001101101" => q                  <= "001100110010";

				when "001101110" => q                  <= "001100100111";
				when "001101111" => q                  <= "001100011100";
				when "001110000" => q                  <= "001100010010";
				when "001110001" => q                  <= "001100000111";
				when "001110010" => q                  <= "001011111101";

				when "001110011" => q                  <= "001011110011";
				when "001110100" => q                  <= "001011101001";
				when "001110101" => q                  <= "001011011111";
				when "001110110" => q                  <= "001011010101";
				when "001110111" => q                  <= "001011001100";

				when "001111000" => q                  <= "001011000010";
				when "001111001" => q                  <= "001010111001";
				when "001111010" => q                  <= "001010110000";
				when "001111011" => q                  <= "001010100110";
				when "001111100" => q                  <= "001010011101";

				when "001111101" => q                  <= "001010010101";
				when "001111110" => q                  <= "001010001100";
				when "001111111" => q                  <= "001010000011";
				when "010000000" => q                  <= "001001111011";
				when "010000001" => q                  <= "001001110010";

				when "010000010" => q                  <= "001001101010";
				when "010000011" => q                  <= "001001100010";
				when "010000100" => q                  <= "001001011010";
				when "010000101" => q                  <= "001001010010";
				when "010000110" => q                  <= "001001001010";

				when "010000111" => q                  <= "001001000010";
				when "010001000" => q                  <= "001000111010";
				when "010001001" => q                  <= "001000110011";
				when "010001010" => q                  <= "001000101011";
				when "010001011" => q                  <= "001000100100";

				when "010001100" => q                  <= "001000011101";
				when "010001101" => q                  <= "001000010110";
				when "010001110" => q                  <= "001000001110";
				when "010001111" => q                  <= "001000001000";
				when "010010000" => q                  <= "001000000001";

				when "010010001" => q                  <= "000111111010";
				when "010010010" => q                  <= "000111110011";
				when "010010011" => q                  <= "000111101101";
				when "010010100" => q                  <= "000111100110";
				when "010010101" => q                  <= "000111100000";

				when "010010110" => q                  <= "000111011001";
				when "010010111" => q                  <= "000111010011";
				when "010011000" => q                  <= "000111001101";
				when "010011001" => q                  <= "000111000111";
				when "010011010" => q                  <= "000111000001";

				when "010011011" => q                  <= "000110111011";
				when "010011100" => q                  <= "000110110101";
				when "010011101" => q                  <= "000110101111";
				when "010011110" => q                  <= "000110101001";
				when "010011111" => q                  <= "000110100100";

				when "010100000" => q                  <= "000110011110";
				when "010100001" => q                  <= "000110011001";
				when "010100010" => q                  <= "000110010011";
				when "010100011" => q                  <= "000110001110";
				when "010100100" => q                  <= "000110001001";

				when "010100101" => q                  <= "000110000011";
				when "010100110" => q                  <= "000101111110";
				when "010100111" => q                  <= "000101111001";
				when "010101000" => q                  <= "000101110100";
				when "010101001" => q                  <= "000101101111";

				when "010101010" => q                  <= "000101101010";
				when "010101011" => q                  <= "000101100101";
				when "010101100" => q                  <= "000101100001";
				when "010101101" => q                  <= "000101011100";
				when "010101110" => q                  <= "000101010111";

				when "010101111" => q                  <= "000101010011";
				when "010110000" => q                  <= "000101001110";
				when "010110001" => q                  <= "000101001010";
				when "010110010" => q                  <= "000101000110";
				when "010110011" => q                  <= "000101000001";

				when "010110100" => q                  <= "000100111101";
				when "010110101" => q                  <= "000100111001";
				when "010110110" => q                  <= "000100110101";
				when "010110111" => q                  <= "000100110001";
				when "010111000" => q                  <= "000100101101";

				when "010111001" => q                  <= "000100101001";
				when "010111010" => q                  <= "000100100101";
				when "010111011" => q                  <= "000100100001";
				when "010111100" => q                  <= "000100011101";
				when "010111101" => q                  <= "000100011001";

				when "010111110" => q                  <= "000100010101";
				when "010111111" => q                  <= "000100010010";
				when "011000000" => q                  <= "000100001110";
				when "011000001" => q                  <= "000100001010";
				when "011000010" => q                  <= "000100000111";

				when "011000011" => q                  <= "000100000011";
				when "011000100" => q                  <= "000100000000";
				when "011000101" => q                  <= "000011111101";
				when "011000110" => q                  <= "000011111001";
				when "011000111" => q                  <= "000011110110";

				when "011001000" => q                  <= "000011110011";
				when "011001001" => q                  <= "000011101111";
				when "011001010" => q                  <= "000011101100";
				when "011001011" => q                  <= "000011101001";
				when "011001100" => q                  <= "000011100110";

				when "011001101" => q                  <= "000011100011";
				when "011001110" => q                  <= "000011100000";
				when "011001111" => q                  <= "000011011101";
				when "011010000" => q                  <= "000011011010";
				when "011010001" => q                  <= "000011010111";

				when "011010010" => q                  <= "000011010100";
				when "011010011" => q                  <= "000011010010";
				when "011010100" => q                  <= "000011001111";
				when "011010101" => q                  <= "000011001100";
				when "011010110" => q                  <= "000011001001";

				when "011010111" => q                  <= "000011000111";
				when "011011000" => q                  <= "000011000100";
				when "011011001" => q                  <= "000011000001";
				when "011011010" => q                  <= "000010111111";
				when "011011011" => q                  <= "000010111100";

				when "011011100" => q                  <= "000010111010";
				when "011011101" => q                  <= "000010110111";
				when "011011110" => q                  <= "000010110101";
				when "011011111" => q                  <= "000010110010";
				when "011100000" => q                  <= "000010110000";

				when "011100001" => q                  <= "000010101110";
				when "011100010" => q                  <= "000010101011";
				when "011100011" => q                  <= "000010101001";
				when "011100100" => q                  <= "000010100111";
				when "011100101" => q                  <= "000010100101";

				when "011100110" => q                  <= "000010100011";
				when "011100111" => q                  <= "000010100000";
				when "011101000" => q                  <= "000010011110";
				when "011101001" => q                  <= "000010011100";
				when "011101010" => q                  <= "000010011010";

				when "011101011" => q                  <= "000010011000";
				when "011101100" => q                  <= "000010010110";
				when "011101101" => q                  <= "000010010100";
				when "011101110" => q                  <= "000010010010";
				when "011101111" => q                  <= "000010010000";

				when "011110000" => q                  <= "000010001110";
				when "011110001" => q                  <= "000010001100";
				when "011110010" => q                  <= "000010001010";
				when "011110011" => q                  <= "000010001001";
				when "011110100" => q                  <= "000010000111";

				when "011110101" => q                  <= "000010000101";
				when "011110110" => q                  <= "000010000011";
				when "011110111" => q                  <= "000010000001";
				when "011111000" => q                  <= "000010000000";
				when "011111001" => q                  <= "000001111110";

				when "011111010" => q                  <= "000001111100";
				when "011111011" => q                  <= "000001111011";
				when "011111100" => q                  <= "000001111001";
				when "011111101" => q                  <= "000001110111";
				when "011111110" => q                  <= "000001110110";

				when "011111111" => q                  <= "000001110100";
				when "100000000" => q                  <= "000001110011";
				when "100000001" => q                  <= "000001110001";
				when "100000010" => q                  <= "000001110000";
				when "100000011" => q                  <= "000001101110";

				when "100000100" => q                  <= "000001101101";
				when "100000101" => q                  <= "000001101011";
				when "100000110" => q                  <= "000001101010";
				when "100000111" => q                  <= "000001101000";
				when "100001000" => q                  <= "000001100111";

				when "100001001" => q                  <= "000001100110";
				when "100001010" => q                  <= "000001100100";
				when "100001011" => q                  <= "000001100011";
				when "100001100" => q                  <= "000001100010";
				when "100001101" => q                  <= "000001100000";

				when "100001110" => q                  <= "000001011111";
				when "100001111" => q                  <= "000001011110";
				when "100010000" => q                  <= "000001011101";
				when "100010001" => q                  <= "000001011011";
				when "100010010" => q                  <= "000001011010";

				when "100010011" => q                  <= "000001011001";
				when "100010100" => q                  <= "000001011000";
				when "100010101" => q                  <= "000001010111";
				when "100010110" => q                  <= "000001010101";
				when "100010111" => q                  <= "000001010100";

				when "100011000" => q                  <= "000001010011";
				when "100011001" => q                  <= "000001010010";
				when "100011010" => q                  <= "000001010001";
				when "100011011" => q                  <= "000001010000";
				when "100011100" => q                  <= "000001001111";

				when "100011101" => q                  <= "000001001110";
				when "100011110" => q                  <= "000001001101";
				when "100011111" => q                  <= "000001001100";
				when "100100000" => q                  <= "000001001011";
				when "100100001" => q                  <= "000001001010";

				when "100100010" => q                  <= "000001001001";
				when "100100011" => q                  <= "000001001000";
				when "100100100" => q                  <= "000001000111";
				when "100100101" => q                  <= "000001000110";
				when "100100110" => q                  <= "000001000101";

				when "100100111" => q                  <= "000001000100";
				when "100101000" => q                  <= "000001000011";
				when "100101001" => q                  <= "000001000010";
				when "100101010" => q                  <= "000001000001";
				when "100101011" => q                  <= "000001000000";

				when "100101100" => q                  <= "000001000000";

				when others      => q                  <= "000000000000";
			end case;
		end if;
	end process Process_1;
end functional;
